{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "d:\\Program Files\\Python312\\Lib\\site-packages\\jieba\\_compat.py:18: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n",
      "  import pkg_resources\n"
     ]
    }
   ],
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征矩阵：\n",
      "[[ 0.  1.  0. 20.]\n",
      " [ 1.  0.  0. 25.]\n",
      " [ 0.  0.  1. 30.]\n",
      " [ 0.  1.  0. 22.]]\n",
      "\n",
      "特征名称：\n",
      "['city=上海' 'city=北京' 'city=广州' 'temperature']\n",
      "\n",
      "转换回字典：\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(20.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(25.0)}, {'city=广州': np.float64(1.0), 'temperature': np.float64(30.0)}, {'city=北京': np.float64(1.0), 'temperature': np.float64(22.0)}]\n"
     ]
    }
   ],
   "source": [
    "# 写一个例子理解DictVectorizer  对字典数据进行特征值化\n",
    "# 创建一个包含字典的列表，每个字典代表一个样本的特征\n",
    "data = [\n",
    "    {'city': '北京', 'temperature': 20},\n",
    "    {'city': '上海', 'temperature': 25},\n",
    "    {'city': '广州', 'temperature': 30},\n",
    "    {'city': '北京', 'temperature': 22}\n",
    "]\n",
    "\n",
    "# 创建DictVectorizer对象\n",
    "vec = DictVectorizer(sparse=False)\n",
    "\n",
    "# 将字典列表转换为特征矩阵\n",
    "X = vec.fit_transform(data)\n",
    "\n",
    "# 打印特征矩阵\n",
    "print(\"特征矩阵：\")\n",
    "print(X.toarray())\n",
    "\n",
    "# 打印特征名称\n",
    "print(\"\\n特征名称：\")\n",
    "print(vec.get_feature_names_out())\n",
    "\n",
    "# 将特征矩阵转换回字典列表\n",
    "print(\"\\n转换回字典：\")\n",
    "print(vec.inverse_transform(X))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "词频矩阵：\n",
      "[[0 0 0 0 0 1 1 1 0 0]\n",
      " [0 0 0 1 1 1 0 1 0 0]\n",
      " [0 0 1 0 0 0 1 0 0 1]\n",
      " [1 1 1 0 0 1 0 1 1 1]]\n",
      "\n",
      "特征名称（词汇表）：\n",
      "['and' 'are' 'data' 'fun' 'is' 'learning' 'love' 'machine' 'related'\n",
      " 'science']\n",
      "\n",
      "每个文档的词频统计：\n",
      "\n",
      "文档 1: I love machine learning\n",
      "词频统计: {'and': np.int64(0), 'are': np.int64(0), 'data': np.int64(0), 'fun': np.int64(0), 'is': np.int64(0), 'learning': np.int64(1), 'love': np.int64(1), 'machine': np.int64(1), 'related': np.int64(0), 'science': np.int64(0)}\n",
      "\n",
      "文档 2: Machine learning is fun\n",
      "词频统计: {'and': np.int64(0), 'are': np.int64(0), 'data': np.int64(0), 'fun': np.int64(1), 'is': np.int64(1), 'learning': np.int64(1), 'love': np.int64(0), 'machine': np.int64(1), 'related': np.int64(0), 'science': np.int64(0)}\n",
      "\n",
      "文档 3: I love data science\n",
      "词频统计: {'and': np.int64(0), 'are': np.int64(0), 'data': np.int64(1), 'fun': np.int64(0), 'is': np.int64(0), 'learning': np.int64(0), 'love': np.int64(1), 'machine': np.int64(0), 'related': np.int64(0), 'science': np.int64(1)}\n",
      "\n",
      "文档 4: Data science and machine learning are related\n",
      "词频统计: {'and': np.int64(1), 'are': np.int64(1), 'data': np.int64(1), 'fun': np.int64(0), 'is': np.int64(0), 'learning': np.int64(1), 'love': np.int64(0), 'machine': np.int64(1), 'related': np.int64(1), 'science': np.int64(1)}\n"
     ]
    }
   ],
   "source": [
    "# CountVectorizer 将英文文本转换为词频矩阵\n",
    "# 创建一个包含文本的列表\n",
    "text_data = [\n",
    "    \"I love machine learning\",\n",
    "    \"Machine learning is fun\",\n",
    "    \"I love data science\",\n",
    "    \"Data science and machine learning are related\"\n",
    "]\n",
    "\n",
    "# 创建CountVectorizer对象\n",
    "vectorizer = CountVectorizer()\n",
    "\n",
    "# 将文本转换为词频矩阵\n",
    "X = vectorizer.fit_transform(text_data)\n",
    "print(type(X))\n",
    "\n",
    "# 打印词频矩阵\n",
    "print(\"词频矩阵：\")\n",
    "print(X.toarray())\n",
    "\n",
    "# 打印特征名称（词汇表）\n",
    "print(\"\\n特征名称（词汇表）：\")\n",
    "print(vectorizer.get_feature_names_out())\n",
    "\n",
    "# 获取每个文档的词频统计\n",
    "print(\"\\n每个文档的词频统计：\")\n",
    "for i, doc in enumerate(text_data):\n",
    "    print(f\"\\n文档 {i+1}: {doc}\")\n",
    "    print(f\"词频统计: {dict(zip(vectorizer.get_feature_names_out(), X.toarray()[i]))}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "精确模式：\n",
      "机器/ 学习/ 是/ 人工智能/ 的/ 一个/ 分支\n",
      "\n",
      "全模式：\n",
      "机器/ 学习/ 是/ 人工/ 人工智能/ 智能/ 的/ 一个/ 分支\n"
     ]
    }
   ],
   "source": [
    "# jieba 中文分词库介绍与示例\n",
    "import jieba\n",
    "\n",
    "# jieba 是一个优秀的中文分词库，支持三种分词模式：\n",
    "# 1. 精确模式：试图将句子最精确地切开，适合文本分析\n",
    "# 2. 全模式：把句子中所有可能的词语都扫描出来，速度快但不能解决歧义\n",
    "# 3. 搜索引擎模式：在精确模式基础上，对长词再次切分，提高召回率，适合搜索引擎分词\n",
    "\n",
    "# 示例文本\n",
    "text = \"机器学习是人工智能的一个分支\"\n",
    "\n",
    "# 1. 精确模式（默认模式）\n",
    "print(\"精确模式：\")\n",
    "seg_list = jieba.cut(text, cut_all=False)\n",
    "print(\"/ \".join(seg_list))\n",
    "\n",
    "# 2. 全模式\n",
    "print(\"\\n全模式：\")\n",
    "seg_list = jieba.cut(text, cut_all=True)\n",
    "print(\"/ \".join(seg_list))\n",
    "\n",
    "# 3. 搜索引擎模式\n",
    "print(\"\\n搜索引擎模式：\")\n",
    "seg_list = jieba.cut_for_search(text)\n",
    "print(\"/ \".join(seg_list))\n",
    "\n",
    "# 精确模式与全模式的区别说明\n",
    "print(\"\\n精确模式与全模式的区别：\")\n",
    "print(\"1. 精确模式（默认）：\")\n",
    "print(\"   - 将文本精确地切分成独立词语\")\n",
    "print(\"   - 尝试找到最可能的词语组合\")\n",
    "print(\"   - 适合文本分析和理解\")\n",
    "print(\"   - 例如：'机器学习/是/人工智能/的/一个/分支'\")\n",
    "\n",
    "print(\"\\n2. 全模式：\")\n",
    "print(\"   - 列出所有可能的词语，不考虑上下文\")\n",
    "print(\"   - 会有重叠和歧义\")\n",
    "print(\"   - 速度较快但精度较低\")\n",
    "print(\"   - 例如：'机器/机器学习/学习/是/人工/人工智能/智能/的/一个/分支'\")\n",
    "\n",
    "print(\"\\n3. 搜索引擎模式：\")\n",
    "print(\"   - 精确模式的基础上，对长词再次切分\")\n",
    "print(\"   - 提高召回率，适合搜索引擎使用\")\n",
    "print(\"   - 例如：'机器/学习/机器学习/是/人工/智能/人工智能/的/一个/分支'\")\n",
    "\n",
    "# 对比示例\n",
    "complex_text = \"北京大学计算机科学与技术系的教授正在研究自然语言处理\"\n",
    "print(\"\\n对比示例文本：\", complex_text)\n",
    "\n",
    "print(\"\\n精确模式分词结果：\")\n",
    "print(\"/ \".join(jieba.cut(complex_text, cut_all=False)))\n",
    "\n",
    "print(\"\\n全模式分词结果：\")\n",
    "print(\"/ \".join(jieba.cut(complex_text, cut_all=True)))\n",
    "\n",
    "print(\"\\n搜索引擎模式分词结果：\")\n",
    "print(\"/ \".join(jieba.cut_for_search(complex_text)))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "## CountVectorizer文本特征提取示例 ##\n",
      "\n",
      "CountVectorizer是scikit-learn库中用于文本特征提取的工具，它可以将文本转换为词频向量。\n",
      "下面通过一个简单的中文例子来说明其用法：\n",
      "\n",
      "示例文档：\n",
      "文档1: 机器学习是人工智能的一个分支\n",
      "文档2: 深度学习是机器学习的一种方法\n",
      "文档3: 自然语言处理是人工智能的重要应用\n",
      "文档4: 机器学习和深度学习都是热门技术\n",
      "\n",
      "词汇表（特征）：\n",
      "['一个' '一种' '人工智能' '分支' '和' '处理' '学习' '应用' '技术' '方法' '是' '机器' '深度' '热门' '的'\n",
      " '自然语言' '都' '重要']\n",
      "\n",
      "词频矩阵：\n",
      "   一个  一种  人工智能  分支  和  处理  学习  应用  技术  方法  是  机器  深度  热门  的  自然语言  都  重要\n",
      "0   1   0     1   1  0   0   1   0   0   0  1   1   0   0  1     0  0   0\n",
      "1   0   1     0   0  0   0   2   0   0   1  1   1   1   0  1     0  0   0\n",
      "2   0   0     1   0  0   1   0   1   0   0  1   0   0   0  1     1  0   1\n",
      "3   0   0     0   0  1   0   2   0   1   0  1   1   1   1  0     0  1   0\n",
      "\n",
      "CountVectorizer的主要特点：\n",
      "1. 将文本转换为词频向量，每个元素表示对应词在文档中出现的次数\n",
      "2. 自动构建词汇表，忽略标点符号和常见停用词\n",
      "3. 可以设置词频阈值，忽略过于罕见或过于常见的词\n",
      "4. 适合用于后续的机器学习算法，如文本分类、聚类等\n",
      "\n",
      "注意事项：\n",
      "- 对于中文文本，需要先进行分词处理\n",
      "- 词袋模型忽略了词的顺序信息\n",
      "- 可以考虑使用TF-IDF转换来减少常见词的权重\n"
     ]
    }
   ],
   "source": [
    "# 使用CountVectorizer进行文本特征提取示例\n",
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "print(\"## CountVectorizer文本特征提取示例 ##\")\n",
    "print(\"\\nCountVectorizer是scikit-learn库中用于文本特征提取的工具，它可以将文本转换为词频向量。\")\n",
    "print(\"下面通过一个简单的中文例子来说明其用法：\")\n",
    "\n",
    "# 准备一些中文文档样本\n",
    "documents = [\n",
    "    \"机器学习是人工智能的一个分支\",\n",
    "    \"深度学习是机器学习的一种方法\",\n",
    "    \"自然语言处理是人工智能的重要应用\",\n",
    "    \"机器学习和深度学习都是热门技术\"\n",
    "]\n",
    "\n",
    "print(\"\\n示例文档：\")\n",
    "for i, doc in enumerate(documents):\n",
    "    print(f\"文档{i+1}: {doc}\")\n",
    "\n",
    "# 使用jieba分词处理中文文本\n",
    "def tokenize_chinese(text):\n",
    "    return list(jieba.cut(text))\n",
    "\n",
    "# 创建CountVectorizer实例，使用jieba分词\n",
    "vectorizer = CountVectorizer(tokenizer=tokenize_chinese, token_pattern=None)\n",
    "\n",
    "# 将文档转换为词频矩阵\n",
    "X = vectorizer.fit_transform(documents)\n",
    "\n",
    "# 获取特征名称（词汇表）\n",
    "feature_names = vectorizer.get_feature_names_out()\n",
    "\n",
    "# 将结果转换为DataFrame以便于查看\n",
    "df = pd.DataFrame(X.toarray(), columns=feature_names)\n",
    "\n",
    "print(\"\\n词汇表（特征）：\")\n",
    "print(feature_names)\n",
    "\n",
    "print(\"\\n词频矩阵：\")\n",
    "print(df)\n",
    "\n",
    "print(\"\\nCountVectorizer的主要特点：\")\n",
    "print(\"1. 将文本转换为词频向量，每个元素表示对应词在文档中出现的次数\")\n",
    "print(\"2. 自动构建词汇表，忽略标点符号和常见停用词\")\n",
    "print(\"3. 可以设置词频阈值，忽略过于罕见或过于常见的词\")\n",
    "print(\"4. 适合用于后续的机器学习算法，如文本分类、聚类等\")\n",
    "\n",
    "print(\"\\n注意事项：\")\n",
    "print(\"- 对于中文文本，需要先进行分词处理\")\n",
    "print(\"- 词袋模型忽略了词的顺序信息\")\n",
    "print(\"- 可以考虑使用TF-IDF转换来减少常见词的权重\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "=== TF-IDF示例 ===\n",
      "\n",
      "TF-IDF矩阵：\n",
      "         一个        一种      人工智能        分支         和        处理        学习  \\\n",
      "0  0.492895  0.000000  0.388604  0.492895  0.000000  0.000000  0.314609   \n",
      "1  0.000000  0.432808  0.000000  0.000000  0.000000  0.000000  0.552512   \n",
      "2  0.000000  0.000000  0.342421  0.000000  0.000000  0.434318  0.000000   \n",
      "3  0.000000  0.000000  0.000000  0.000000  0.379842  0.000000  0.484897   \n",
      "\n",
      "         应用        技术        方法         是        机器        深度        热门  \\\n",
      "0  0.000000  0.000000  0.000000  0.257213  0.314609  0.000000  0.000000   \n",
      "1  0.000000  0.000000  0.432808  0.225857  0.276256  0.341231  0.000000   \n",
      "2  0.434318  0.000000  0.000000  0.226645  0.000000  0.000000  0.000000   \n",
      "3  0.000000  0.379842  0.000000  0.198217  0.242448  0.299472  0.379842   \n",
      "\n",
      "          的      自然语言         都        重要  \n",
      "0  0.314609  0.000000  0.000000  0.000000  \n",
      "1  0.276256  0.000000  0.000000  0.000000  \n",
      "2  0.277220  0.434318  0.000000  0.434318  \n",
      "3  0.000000  0.000000  0.379842  0.000000  \n",
      "\n",
      "TF-IDF的主要特点：\n",
      "1. TF-IDF = 词频(TF) × 逆文档频率(IDF)\n",
      "2. 词频(TF)：词在文档中出现的次数\n",
      "3. 逆文档频率(IDF)：log(总文档数/包含该词的文档数)\n",
      "4. 减少了常见词的权重，增加了独特词的权重\n",
      "5. 比单纯的词频计数提供更有意义的特征表示\n"
     ]
    }
   ],
   "source": [
    "# TF-IDF示例  将中文文本转换为TF-IDF矩阵\n",
    "print(\"\\n\\n=== TF-IDF示例 ===\")\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "\n",
    "# 使用TfidfVectorizer，同样使用jieba分词\n",
    "tfidf_vectorizer = TfidfVectorizer(tokenizer=tokenize_chinese, token_pattern=None)\n",
    "\n",
    "# 将文档转换为TF-IDF矩阵\n",
    "X_tfidf = tfidf_vectorizer.fit_transform(documents)\n",
    "\n",
    "# 获取特征名称（词汇表）\n",
    "tfidf_feature_names = tfidf_vectorizer.get_feature_names_out()\n",
    "\n",
    "# 将结果转换为DataFrame以便于查看\n",
    "tfidf_df = pd.DataFrame(X_tfidf.toarray(), columns=tfidf_feature_names)\n",
    "\n",
    "print(\"\\nTF-IDF矩阵：\")\n",
    "print(tfidf_df)\n",
    "\n",
    "print(\"\\nTF-IDF的主要特点：\")\n",
    "print(\"1. TF-IDF = 词频(TF) × 逆文档频率(IDF)\")\n",
    "print(\"2. 词频(TF)：词在文档中出现的次数\")\n",
    "print(\"3. 逆文档频率(IDF)：log(总文档数/包含该词的文档数)\")\n",
    "print(\"4. 减少了常见词的权重，增加了独特词的权重\")\n",
    "print(\"5. 比单纯的词频计数提供更有意义的特征表示\")\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "=== 归一化示例 ===\n",
      "创建一个示例特征矩阵：\n",
      "[[ 1 -1  2]\n",
      " [ 2  0  0]\n",
      " [ 0  1 -1]\n",
      " [ 5  2  8]]\n",
      "\n",
      "1. Min-Max归一化 (特征缩放到[0,1]区间):\n",
      "[[0.2        0.         0.33333333]\n",
      " [0.4        0.33333333 0.11111111]\n",
      " [0.         0.66666667 0.        ]\n",
      " [1.         1.         1.        ]]\n",
      "\n",
      "归一化的数学原理:\n",
      "Min-Max归一化原理:\n",
      "X_norm = (X - X_min) / (X_max - X_min)\n",
      "- 将每个特征的值减去该特征的最小值\n",
      "- 然后除以该特征的范围(最大值-最小值)\n",
      "- 结果：所有特征都被映射到[0,1]区间\n",
      "\n",
      "标准化(Z-score)原理:\n",
      "X_std = (X - μ) / σ\n",
      "- 将每个特征的值减去该特征的均值(μ)\n",
      "- 然后除以该特征的标准差(σ)\n",
      "- 结果：转换后的数据均值为0，标准差为1\n",
      "\n",
      "2. 标准化(Z-score):\n",
      "   - 转换为均值为0、标准差为1的分布\n",
      "   - 对异常值不太敏感\n",
      "   - 不产生有界的结果\n",
      "   - 适用场景：SVM、线性回归、逻辑回归等\n",
      "标准化基于均值和标准差，受极端值影响较小\n",
      "\n",
      "3. 归一化的重要性:\n",
      "   - 消除特征间量纲和数值范围的差异\n",
      "   - 加速梯度下降收敛\n",
      "   - 提高模型性能和稳定性\n",
      "   - 防止某些特征因数值较大而主导模型\n",
      "将数据映射到特定区间（如 [0,1] 或 [-1,1]），消除不同特征的量纲影响，使数据在相同尺度下比较\n"
     ]
    }
   ],
   "source": [
    "# 归一化示例\n",
    "print(\"\\n\\n=== 归一化示例 ===\")\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "import numpy as np\n",
    "\n",
    "# 创建一个示例特征矩阵\n",
    "print(\"创建一个示例特征矩阵：\")\n",
    "X = np.array([\n",
    "    [1, -1, 2],\n",
    "    [2, 0, 0],\n",
    "    [0, 1, -1],\n",
    "    [5, 2, 8]\n",
    "])\n",
    "print(X)\n",
    "\n",
    "# 1. Min-Max归一化 (将数据缩放到[0,1]区间)\n",
    "print(\"\\n1. Min-Max归一化 (特征缩放到[0,1]区间):\")\n",
    "min_max_scaler = MinMaxScaler()\n",
    "X_minmax = min_max_scaler.fit_transform(X)\n",
    "print(X_minmax)\n",
    "# 归一化原理解释\n",
    "print(\"\\n归一化的数学原理:\")\n",
    "\n",
    "# Min-Max归一化原理\n",
    "print(\"Min-Max归一化原理:\")\n",
    "print(\"X_norm = (X - X_min) / (X_max - X_min)\")\n",
    "print(\"- 将每个特征的值减去该特征的最小值\")\n",
    "print(\"- 然后除以该特征的范围(最大值-最小值)\")\n",
    "print(\"- 结果：所有特征都被映射到[0,1]区间\")\n",
    "\n",
    "# 标准化原理\n",
    "print(\"\\n标准化(Z-score)原理:\")\n",
    "print(\"X_std = (X - μ) / σ\")\n",
    "print(\"- 将每个特征的值减去该特征的均值(μ)\")\n",
    "print(\"- 然后除以该特征的标准差(σ)\")\n",
    "print(\"- 结果：转换后的数据均值为0，标准差为1\")\n",
    "\n",
    "\n",
    "\n",
    "print(\"\\n2. 标准化(Z-score):\")\n",
    "print(\"   - 转换为均值为0、标准差为1的分布\")\n",
    "print(\"   - 对异常值不太敏感\")\n",
    "print(\"   - 不产生有界的结果\")\n",
    "print(\"   - 适用场景：SVM、线性回归、逻辑回归等\")\n",
    "print(\"标准化基于均值和标准差，受极端值影响较小\")\n",
    "\n",
    "\n",
    "print(\"\\n3. 归一化的重要性:\")\n",
    "print(\"   - 消除特征间量纲和数值范围的差异\")\n",
    "print(\"   - 加速梯度下降收敛\")\n",
    "print(\"   - 提高模型性能和稳定性\")\n",
    "print(\"   - 防止某些特征因数值较大而主导模型\")\n",
    "print(\"将数据映射到特定区间（如 [0,1] 或 [-1,1]），消除不同特征的量纲影响，使数据在相同尺度下比较\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "方差阈值特征选择 (VarianceThreshold):\n",
      "方差阈值是一种简单的无监督特征选择方法，它会移除方差不满足某个阈值的所有特征。\n",
      "原理：如果一个特征的方差很小，说明该特征的值变化很小，对模型的贡献可能有限。\n",
      "\n",
      "每个特征的方差:\n",
      "特征 1: 0.1600\n",
      "特征 2: 0.2400\n",
      "特征 3: 2.2400\n",
      "特征 4: 0.1600\n",
      "\n",
      "不同方差阈值下保留的特征数量:\n",
      "阈值 0.0: 保留 4 个特征\n",
      "阈值 0.5: 保留 1 个特征\n",
      "阈值 1.0: 保留 1 个特征\n",
      "阈值 2.0: 保留 1 个特征\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "方差阈值特征选择的优缺点:\n",
      "优点:\n",
      "- 计算简单，易于实现\n",
      "- 不需要标签信息(无监督)\n",
      "- 可以快速移除低信息量特征\n",
      "\n",
      "缺点:\n",
      "- 不考虑特征与目标变量的关系\n",
      "- 可能会移除对预测有用但方差小的特征\n",
      "- 对特征的尺度敏感，通常需要先进行标准化\n"
     ]
    }
   ],
   "source": [
    "# 方差阈值特征选择\n",
    "import numpy as np\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "print(\"\\n方差阈值特征选择 (VarianceThreshold):\")\n",
    "print(\"方差阈值是一种简单的无监督特征选择方法，它会移除方差不满足某个阈值的所有特征。\")\n",
    "print(\"原理：如果一个特征的方差很小，说明该特征的值变化很小，对模型的贡献可能有限。\")\n",
    "\n",
    "# 创建一个示例数据集\n",
    "X_var = np.array([\n",
    "    [0, 2, 0, 3],\n",
    "    [0, 1, 4, 3],\n",
    "    [0, 1, 1, 3],\n",
    "    [1, 2, 0, 4],\n",
    "    [0, 1, 2, 3]\n",
    "])\n",
    "\n",
    "# 计算每个特征的方差\n",
    "feature_variances = np.var(X_var, axis=0)\n",
    "print(\"\\n每个特征的方差:\")\n",
    "for i, var in enumerate(feature_variances):\n",
    "    print(f\"特征 {i+1}: {var:.4f}\")\n",
    "\n",
    "# 使用不同阈值进行特征选择\n",
    "thresholds = [0.0, 0.5, 1.0, 2.0]\n",
    "selected_features = []\n",
    "\n",
    "print(\"\\n不同方差阈值下保留的特征数量:\")\n",
    "for threshold in thresholds:\n",
    "    # 创建一个VarianceThreshold对象，设置方差阈值为threshold\n",
    "    # 这个选择器会移除所有方差小于threshold的特征\n",
    "    # 当threshold=0.0时，只移除方差为0的特征（即常量特征）\n",
    "    # 当threshold值增大时，会移除更多的低方差特征\n",
    "    selector = VarianceThreshold(threshold=threshold)\n",
    "    try:\n",
    "        # 使用方差阈值选择器对数据进行特征选择\n",
    "        # fit_transform方法首先通过fit()学习数据的方差特征，然后通过transform()移除低方差特征\n",
    "        # 具体步骤：\n",
    "        # 1. 计算每个特征的方差\n",
    "        # 2. 确定哪些特征的方差大于或等于设定的阈值threshold\n",
    "        # 3. 仅保留那些方差大于或等于阈值的特征列\n",
    "        X_selected = selector.fit_transform(X_var)\n",
    "        \n",
    "        # 获取选择后保留的特征数量\n",
    "        # X_selected是经过特征选择后的数据矩阵\n",
    "        # shape[1]返回矩阵的列数，即保留下来的特征数量\n",
    "        # 当阈值增大时，保留的特征数量通常会减少，因为更多的低方差特征会被过滤掉\n",
    "        n_selected = X_selected.shape[1]\n",
    "        selected_features.append(n_selected)  # 将保留的特征数量添加到列表中，用于后续可视化\n",
    "        print(f\"阈值 {threshold:.1f}: 保留 {n_selected} 个特征\")  # 打印当前阈值下保留的特征数量\n",
    "    except ValueError as e:  # 捕获可能出现的异常，例如当所有特征都被移除时\n",
    "        print(f\"阈值 {threshold:.1f}: {e}\")\n",
    "        selected_features.append(0)\n",
    "# 解决中文显示问题\n",
    "plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签\n",
    "plt.rcParams['axes.unicode_minus'] = False    # 用来正常显示负号\n",
    "\n",
    "# 可视化不同阈值下保留的特征数量\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(thresholds, selected_features)\n",
    "plt.xlabel('方差阈值')\n",
    "plt.ylabel('保留的特征数量')\n",
    "plt.title('方差阈值与保留特征数量的关系')\n",
    "plt.grid(True, linestyle='--', alpha=0.7)\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "print(\"\\n方差阈值特征选择的优缺点:\")\n",
    "print(\"优点:\")\n",
    "print(\"- 计算简单，易于实现\")\n",
    "print(\"- 不需要标签信息(无监督)\")\n",
    "print(\"- 可以快速移除低信息量特征\")\n",
    "print(\"\\n缺点:\")\n",
    "print(\"- 不考虑特征与目标变量的关系\")\n",
    "print(\"- 可能会移除对预测有用但方差小的特征\")\n",
    "print(\"- 对特征的尺度敏感，通常需要先进行标准化\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "主成分分析(PCA)的原理:\n",
      "1. 基本思想:\n",
      "   - PCA是一种降维技术，通过线性变换将原始高维数据投影到新的低维空间\n",
      "   - 新的坐标轴(主成分)按照数据方差从大到小排序，保留最大方差方向的信息\n",
      "   - 每个主成分都是原始特征的线性组合，且相互正交\n",
      "\n",
      "2. 数学原理:\n",
      "   - 计算原始数据的协方差矩阵\n",
      "   - 对协方差矩阵进行特征值分解，得到特征值和特征向量\n",
      "   - 特征值表示对应主成分的方差大小，特征向量表示主成分的方向\n",
      "   - 按特征值大小降序排列，选择前k个特征向量组成投影矩阵\n",
      "   - 通过投影矩阵将原始数据转换到新的特征空间\n",
      "\n",
      "3. PCA的优点:\n",
      "   - 有效降低数据维度，减少计算复杂度\n",
      "   - 去除噪声和冗余信息\n",
      "   - 可以处理特征之间的相关性\n",
      "   - 保留数据中最重要的变异信息\n",
      "\n",
      "4. PCA的局限性:\n",
      "   - 仅捕捉线性关系，无法处理非线性数据结构\n",
      "   - 难以解释转换后的特征物理含义\n",
      "   - 对异常值敏感\n",
      "   - 可能丢失对目标变量预测有用的信息\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\1\\AppData\\Local\\Temp\\ipykernel_1708\\2375836965.py:38: RuntimeWarning: covariance is not symmetric positive-semidefinite.\n",
      "  data = np.random.multivariate_normal(mean, cov, 200)  # 生成200个服从多元正态分布的数据点\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "解释方差比例: [0.99015454 0.00984546]\n",
      "第一主成分解释了99.02%的数据方差\n",
      "第二主成分解释了0.98%的数据方差\n"
     ]
    }
   ],
   "source": [
    "# 主成分分析(PCA)原理解释\n",
    "\n",
    "print(\"\\n主成分分析(PCA)的原理:\")\n",
    "print(\"1. 基本思想:\")\n",
    "print(\"   - PCA是一种降维技术，通过线性变换将原始高维数据投影到新的低维空间\")\n",
    "print(\"   - 新的坐标轴(主成分)按照数据方差从大到小排序，保留最大方差方向的信息\")\n",
    "print(\"   - 每个主成分都是原始特征的线性组合，且相互正交\")\n",
    "\n",
    "print(\"\\n2. 数学原理:\")\n",
    "print(\"   - 计算原始数据的协方差矩阵\")\n",
    "print(\"   - 对协方差矩阵进行特征值分解，得到特征值和特征向量\")\n",
    "print(\"   - 特征值表示对应主成分的方差大小，特征向量表示主成分的方向\")\n",
    "print(\"   - 按特征值大小降序排列，选择前k个特征向量组成投影矩阵\")\n",
    "print(\"   - 通过投影矩阵将原始数据转换到新的特征空间\")\n",
    "\n",
    "print(\"\\n3. PCA的优点:\")\n",
    "print(\"   - 有效降低数据维度，减少计算复杂度\")\n",
    "print(\"   - 去除噪声和冗余信息\")\n",
    "print(\"   - 可以处理特征之间的相关性\")\n",
    "print(\"   - 保留数据中最重要的变异信息\")\n",
    "\n",
    "print(\"\\n4. PCA的局限性:\")\n",
    "print(\"   - 仅捕捉线性关系，无法处理非线性数据结构\")\n",
    "print(\"   - 难以解释转换后的特征物理含义\")\n",
    "print(\"   - 对异常值敏感\")\n",
    "print(\"   - 可能丢失对目标变量预测有用的信息\")\n",
    "\n",
    "# 简单的PCA可视化示例\n",
    "from sklearn.decomposition import PCA\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# 创建一个简单的二维数据示例\n",
    "np.random.seed(42)  # 设置随机种子为42，确保结果可重现\n",
    "# 生成相关性较强的二维数据\n",
    "cov = [[3, 2.5], [2.5, 2]]  # 定义协方差矩阵，表示两个变量之间有较强的相关性\n",
    "mean = [0, 0]  # 定义均值向量，这里设置为原点\n",
    "data = np.random.multivariate_normal(mean, cov, 200)  # 生成200个服从多元正态分布的数据点\n",
    "\n",
    "# 应用PCA\n",
    "pca = PCA(n_components=2)  # 创建PCA对象，保留2个主成分\n",
    "data_pca = pca.fit_transform(data)  # 对数据进行PCA转换，fit_transform同时完成拟合和转换\n",
    "\n",
    "# 可视化原始数据和PCA主成分方向\n",
    "plt.figure(figsize=(10, 8))  # 创建一个10x8英寸的图形\n",
    "plt.scatter(data[:, 0], data[:, 1], alpha=0.7, label='原始数据点')  # 绘制原始数据散点图，透明度为0.7\n",
    "\n",
    "# 绘制主成分方向\n",
    "for i, (comp, var) in enumerate(zip(pca.components_, pca.explained_variance_)):  # 遍历每个主成分及其对应的方差\n",
    "    comp = comp * var  # 按方差缩放主成分向量，使其长度与方差成正比\n",
    "    plt.arrow(0, 0, comp[0], comp[1], head_width=0.1, head_length=0.1,  # 从原点绘制箭头表示主成分方向\n",
    "              fc=f'C{i+2}', ec=f'C{i+2}', label=f'主成分{i+1}')  # 设置箭头颜色和标签\n",
    "\n",
    "plt.xlabel('X轴')  # 设置X轴标签\n",
    "plt.ylabel('Y轴')  # 设置Y轴标签\n",
    "plt.title('PCA主成分示例')  # 设置图表标题\n",
    "plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)  # 绘制水平参考线（y=0）\n",
    "plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)  # 绘制垂直参考线（x=0）\n",
    "plt.grid(alpha=0.3)  # 添加网格线，透明度为0.3\n",
    "plt.legend()  # 添加图例\n",
    "plt.axis('equal')  # 设置X轴和Y轴的比例相同，保证图形不变形\n",
    "plt.show()  # 显示图形\n",
    "\n",
    "print(f\"\\n解释方差比例: {pca.explained_variance_ratio_}\")  # 打印每个主成分解释的方差比例\n",
    "print(f\"第一主成分解释了{pca.explained_variance_ratio_[0]*100:.2f}%的数据方差\")  # 打印第一主成分解释的方差百分比\n",
    "print(f\"第二主成分解释了{pca.explained_variance_ratio_[1]*100:.2f}%的数据方差\")  # 打印第二主成分解释的方差百分比\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
